import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2022-08-13
 * Time: 17:49
 */

//父类
class Animal1 {

    int a;
    int b;

    public void fun1() {
        System.out.println("这是父类中的一个方法fun1");
    }

    public void fun2() {
        System.out.println("这是父类中的一个方法fun2");
    }
}


class bid extends Animal1 {

    public String name;
    public int a; //与父类中的 a 同名且类型相同
    public char b; //与父类中的 b 同名但类型不同

    public void flying() {
        System.out.println(name + " 正在飞");
    }

    public void fun1(int a) {
        System.out.println("这是bid类中得一个重载方法fun1（int）");

    }

    public void fun2() {
        System.out.println("这是bid类中得一个重写方法fun2");
    }

    public void fun3() {

        //访问子类成员时，借助 this 关键字
        a = 100;  //等同于 this.a
        b = 'a';  //等同于 this.b

        //访问父类成员时需要借助 super 关键字
        super.a = 10;
        super.b = 8;

        //子类和父类构成方法的重载时，可以直接通过方法的参数列表区分时使用的父类的方法还是子类的方法
        fun1(); //不带参的直接访问的是父类中的放
        fun1(10); //带参数的直接访问的时子类自己的

        fun2();//子类和父类重写，直接访问永远都是访问的时子类自己的，就近原则
        super.fun2(); //访问的时父类的fun2，通过 super 关键字

    }


}

class fish {

    public String name;

    public void swimming() {
        System.out.println(name + " 正在游泳");
    }
}

class A {
    //final 修饰类则该类不能被继承
    public String name;
    public int age;

    public A(String name, int age) {
        this.age = age;
        this.name = name;
        System.out.println("父类构造方法执行");
    }

    {
        System.out.println("父类实例代码块执行");
    }

    static {
        System.out.println("父类静态代码块执行");
    }

}

class B extends A {


    //如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用
    public B(String name, int age) {
        super(name, age);
        System.out.println("子类构造方法执行");
    }

    {
        System.out.println("子类实例代码块执行");
    }

    static {
        System.out.println("子类静态代码块执行");
    }
}

class C extends B {
    public C(String name, int age) {
        super(name, age);
    }

    public final void fun() {
        System.out.println("final修饰的方法不能被重写！！！");
    }
}

public class Test1_0813 {

    //执行顺序为： 父类静态代码块 》 子类静态代码块 》 父类实例代码块 》 父类构造器 》子类实例代码块 》 子类构造器
    public static void main1(String[] args) {
        B b = new B("xixi", 18);
        System.out.println("==============");

        //第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
        B b1 = new B("haha", 20);
    }


    public static void main2(String[] args) {
        //可以多层继承 B继承A C继承B
        // 一般我们不希望出现超过三层的继承关系
        A a = new A("xixi", 18);
        System.out.println("=============");
        B b = new B("haha", 20);
        System.out.println("=============");
        C c = new C("hehe", 24);

        final int x = 10;
        //x = 15;  //final 修饰的变量或则字段表示常量，无法被修改
    }

    public static void main(String[] args) {

    }
}


